home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The CICA Windows Explosion!
/
The CICA Windows Explosion! - Disc 2.iso
/
nt
/
source.exe
/
POSIX
/
ELVIS
/
INPUT.C
< prev
next >
Wrap
C/C++ Source or Header
|
1992-10-08
|
17KB
|
818 lines
/* input.c */
/* Author:
* Steve Kirkendall
* 14407 SW Teal Blvd. #C
* Beaverton, OR 97005
* kirkenda@cs.pdx.edu
*/
/* This file contains the input() function, which implements vi's INPUT mode.
* It also contains the code that supports digraphs.
*/
#include <ctype.h>
#include "config.h"
#include "vi.h"
#ifndef NO_DIGRAPH
static struct _DIG
{
struct _DIG *next;
char key1;
char key2;
char dig;
char save;
} *digs;
char digraph(key1, key2)
char key1; /* the underlying character */
char key2; /* the second character */
{
int newkey;
REG struct _DIG *dp;
/* if digraphs are disabled, then just return the new char */
if (!*o_digraph)
{
return key2;
}
/* remember the new key, so we can return it if this isn't a digraph */
newkey = key2;
/* sort key1 and key2, so that their original order won't matter */
if (key1 > key2)
{
key2 = key1;
key1 = newkey;
}
/* scan through the digraph chart */
for (dp = digs;
dp && (dp->key1 != key1 || dp->key2 != key2);
dp = dp->next)
{
}
/* if this combination isn't in there, just use the new key */
if (!dp)
{
return newkey;
}
/* else use the digraph key */
return dp->dig;
}
/* this function lists or defines digraphs */
void do_digraph(bang, extra)
int bang;
char extra[];
{
int dig;
REG struct _DIG *dp;
struct _DIG *prev;
static int user_defined = FALSE; /* boolean: are all later digraphs user-defined? */
char listbuf[8];
/* if "extra" is NULL, then we've reached the end of the built-ins */
if (!extra)
{
user_defined = TRUE;
return;
}
/* if no args, then display the existing digraphs */
if (*extra < ' ')
{
listbuf[0] = listbuf[1] = listbuf[2] = listbuf[5] = ' ';
listbuf[7] = '\0';
for (dig = 0, dp = digs; dp; dp = dp->next)
{
if (dp->save || bang)
{
dig += 7;
if (dig >= COLS)
{
addch('\n');
exrefresh();
dig = 7;
}
listbuf[3] = dp->key1;
listbuf[4] = dp->key2;
listbuf[6] = dp->dig;
qaddstr(listbuf);
}
}
addch('\n');
exrefresh();
return;
}
/* make sure we have at least two characters */
if (!extra[1])
{
msg("Digraphs must be composed of two characters");
return;
}
/* sort key1 and key2, so that their original order won't matter */
if (extra[0] > extra[1])
{
dig = extra[0];
extra[0] = extra[1];
extra[1] = dig;
}
/* locate the new digraph character */
for (dig = 2; extra[dig] == ' ' || extra[dig] == '\t'; dig++)
{
}
dig = extra[dig];
if (!bang && dig)
{
dig |= 0x80;
}
/* search for the digraph */
for (prev = (struct _DIG *)0, dp = digs;
dp && (dp->key1 != extra[0] || dp->key2 != extra[1]);
prev = dp, dp = dp->next)
{
}
/* deleting the digraph? */
if (!dig)
{
if (!dp)
{
#ifndef CRUNCH
msg("%c%c not a digraph", extra[0], extra[1]);
#endif
return;
}
if (prev)
prev->next = dp->next;
else
digs = dp->next;
free(dp);
return;
}
/* if necessary, create a new digraph struct for the new digraph */
if (dig && !dp)
{
dp = (struct _DIG *)malloc(sizeof *dp);
if (!dp)
{
msg("Out of space in the digraph table");
return;
}
if (prev)
prev->next = dp;
else
digs = dp;
dp->next = (struct _DIG *)0;
}
/* assign it the new digraph value */
dp->key1 = extra[0];
dp->key2 = extra[1];
dp->dig = dig;
dp->save = user_defined;
}
# ifndef NO_MKEXRC
void savedigs(fd)
int fd;
{
static char buf[] = "digraph! XX Y\n";
REG struct _DIG *dp;
for (dp = digs; dp; dp = dp->next)
{
if (dp->save)
{
buf[9] = dp->key1;
buf[10] = dp->key2;
buf[12] = dp->dig;
write(fd, buf, (unsigned)14);
}
}
}
# endif
#endif
#ifndef NO_ABBR
static struct _AB
{
struct _AB *next;
char *large; /* the expanded form */
char small[1]; /* the abbreviated form (appended to struct) */
}
*abbrev;
/* This functions lists or defines abbreviations */
void do_abbr(extra)
char *extra;
{
int smlen; /* length of the small form */
int lrg; /* index of the start of the large form */
REG struct _AB *ab; /* used to move through the abbrev list */
struct _AB *prev;
/* no arguments? */
if (!*extra)
{
/* list all current abbreviations */
for (ab = abbrev; ab; ab = ab->next)
{
qaddstr("abbr ");
qaddstr(ab->small);
qaddch(' ');
qaddstr(ab->large);
addch('\n');
exrefresh();
}
return;
}
/* else one or more arguments. Parse the first & look up in abbrev[] */
for (smlen = 0; extra[smlen] && isalnum(extra[smlen]); smlen++)
{
}
for (prev = (struct _AB *)0, ab = abbrev; ab; prev = ab, ab = ab->next)
{
if (!strncmp(extra, ab->small, smlen) && !ab->small[smlen])
{
break;
}
}
/* locate the start of the large form, if any */
for (lrg = smlen; extra[lrg] && isascii(extra[lrg]) && isspace(extra[lrg]); lrg++)
{
}
/* only one arg? */
if (!extra[lrg])
{
/* trying to undo an abbreviation which doesn't exist? */
if (!ab)
{
#ifndef CRUNCH
msg("\"%s\" not an abbreviation", extra);
#endif
return;
}
/* undo the abbreviation */
if (prev)
prev->next = ab->next;
else
abbrev = ab->next;
free(ab->large);
free(ab);
return;
}
/* multiple args - [re]define an abbreviation */
if (ab)
{
/* redefining - free the old large form */
free(ab->large);
}
else
{
/* adding a new definition - make a new struct */
ab = (struct _AB *)malloc((unsigned)(smlen + sizeof *ab));
#ifndef CRUNCH
if (!ab)
{
msg("Out of memory -- Sorry");
return;
}
#endif
strncpy(ab->small, extra, smlen);
ab->small[smlen] = '\0';
ab->next = (struct _AB *)0;
if (prev)
prev->next = ab;
else
abbrev = ab;
}
/* store the new form */
ab->large = (char *)malloc((unsigned)(strlen(&extra[lrg]) + 1));
strcpy(ab->large, &extra[lrg]);
}
# ifndef NO_MKEXRC
/* This function is called from cmd_mkexrc() to save the abbreviations */
void saveabbr(fd)
int fd; /* fd to which the :abbr commands should be written */
{
REG struct _AB *ab;
for (ab = abbrev; ab; ab = ab->next)
{
twrite(fd, "abbr ", 5);
twrite(fd, ab->small, strlen(ab->small));
twrite(fd, " ", 1);
twrite(fd, ab->large, strlen(ab->large));
twrite(fd, "\n", 1);
}
}
# endif
/* This function should be called before each char is inserted. If the next
* char is non-alphanumeric and we're at the end of a word, then that word
* is checked against the abbrev[] array and expanded, if appropriate. Upon
* returning from this function, the new char still must be inserted.
*/
static MARK expandabbr(m, ch)
MARK m; /* the cursor position */
int ch; /* the character to insert */
{
char *word; /* where the word starts */
int len; /* length of the word */
REG struct _AB *ab;
/* if no abbreviations are in effect, or ch is aphanumeric, then
* don't do anything
*/
if (!abbrev || !isascii(ch) || isalnum(ch))
{
return m;
}
/* see where the preceding word starts */
pfetch(markline(m));
for (word = ptext + markidx(m), len = 0;
--word >= ptext && (!isascii(*word) || isalnum(*word));
len++)
{
}
word++;
/* if zero-length, then it isn't a word, really -- so nothing */
if (len == 0)
{
return m;
}
/* look it up in the abbrev list */
for (ab = abbrev; ab; ab = ab->next)
{
if (!strncmp(ab->small, word, len) && !ab->small[len])
{
break;
}
}
/* not an abbreviation? then do nothing */
if (!ab)
{
return m;
}
/* else replace the small form with the large form */
add(m, ab->large);
delete(m - len, m);
/* return with the cursor after the end of the large form */
return m - len + strlen(ab->large);
}
#endif
/* This function allows the user to replace an existing (possibly zero-length)
* chunk of text with typed-in text. It returns the MARK of the last character
* that the user typed in.
*/
MARK input(from, to, when)
MARK from; /* where to start inserting text */
MARK to; /* extent of text to delete */
int when; /* either WHEN_VIINP or WHEN_VIREP */
{
char key[2]; /* key char followed by '\0' char */
char *build; /* used in building a newline+indent string */
char *scan; /* used while looking at the indent chars of a line */
MARK m; /* some place in the text */
#ifndef NO_EXTENSIONS
int quit = FALSE; /* boolean: are we exiting after this? */
#endif
#ifdef DEBUG
/* if "from" and "to" are reversed, complain */
if (from > to)
{
msg("ERROR: input(%ld:%d, %ld:%d)",
markline(from), markidx(from),
markline(to), markidx(to));
return MARK_UNSET;
}
#endif
key[1] = 0;
/* if we're replacing text with new text, save the old stuff */
/* (Alas, there is no easy way to save text for replace mode) */
if (from != to)
{
cut(from, to);
}
ChangeText
{
/* if doing a dot command, then reuse the previous text */
if (doingdot)
{
/* delete the text that's there now */
if (from != to)
{
delete(from, to);
}
/* insert the previous text */
cutname('.');
cursor = paste(from, FALSE, TRUE) + 1L;
}
else /* interactive version */
{
/* if doing a change within the line... */
if (from != to && markline(from) == markline(to))
{
/* mark the end of the text with a "$" */
change(to - 1, to, "$");
}
else
{
/* delete the old text right off */
if (from != to)
{
delete(from, to);
}
to = from;
}
/* handle autoindent of the first line, maybe */
cursor = from;
if (*o_autoindent && markline(cursor) > 1L && markidx(cursor) == 0)
{
/* Only autoindent blank lines. */
pfetch(markline(cursor));
if (plen == 0)
{
/* Okay, we really want to autoindent */
pfetch(markline(cursor) - 1L);
for (scan = ptext, build = tmpblk.c;
*scan == ' ' || *scan == '\t';
)
{
*build++ = *scan++;
}
if (build > tmpblk.c)
{
*build = '\0';
add(cursor, tmpblk.c);
cursor += (build - tmpblk.c);
}
}
}
/* repeatedly add characters from the user */
for (;;)
{
/* Get a character */
redraw(cursor, TRUE);
#ifdef DEBUG
msg("cursor=%ld.%d, to=%ld.%d",
markline(cursor), markidx(cursor),
markline(to), markidx(to));
#endif
key[0] = getkey(when);
/* if whitespace & wrapmargin is set & we're
* past the warpmargin, then change the
* whitespace character into a newline
*/
if ((*key == ' ' || *key == '\t')
&& *o_wrapmargin != 0)
{
pfetch(markline(cursor));
if (idx2col(cursor, ptext, TRUE) > COLS - (*o_wrapmargin & 0xff))
{
*key = '\n';
}
}
/* process it */
switch (*key)
{
#ifndef NO_EXTENSIONS
case 0: /* special movement mapped keys */
*key = getkey(0);
switch (*key)
{
case 'h': m = m_left(cursor, 0L); break;
case 'j':
case 'k': m = m_updnto(cursor, 0L, *key); break;
case 'l': m = cursor + 1; break;
case 'b': m = m_bword(cursor, 0L); break;
case 'w': m = m_fword(cursor, 0L); break;
case '^': m = m_front(cursor, 0L); break;
case '$': m = m_rear(cursor, 0L); break;
case ctrl('B'):
case ctrl('F'):
m = m_scroll(cursor, 0L, *key); break;
case 'x': m = v_xchar(cursor, 0L); break;
case 'i': m = to = from = cursor; break;
default: m = MARK_UNSET; break;
}
/* adjust the moved cursor */
m = adjmove(cursor, m, (*key == 'j' || *key == 'k' ? 0x20 : 0));
if (*key == '$' || (*key == 'l' && m <= cursor))
{
m++;
}
/* if the cursor is reasonable, use it */
if (m == MARK_UNSET)
{
beep();
}
else
{
if (to > cursor)
{
delete(cursor, to);
redraw(cursor, TRUE);
}
from = to = cursor = m;
}
break;
case ctrl('Z'):
if (getkey(0) == ctrl('Z'))
{
quit = TRUE;
goto BreakBreak;
}
break;
#endif
case ctrl('['):
#ifndef NO_ABBR
cursor = expandabbr(cursor, ctrl('['));
#endif
goto BreakBreak;
case ctrl('U'):
if (markline(cursor) == markline(from))
{
cursor = from;
}
else
{
cursor &= ~(BLKSIZE - 1);
}
break;
case ctrl('D'):
case ctrl('T'):
if (to > cursor)
{
delete(cursor, to);
}
mark[27] = cursor;
cmd_shift(cursor, cursor, *key == ctrl('D') ? CMD_SHIFTL : CMD_SHIFTR, TRUE, "");
if (mark[27])
{
cursor = mark[27];
}
else
{
cursor = m_front(cursor, 0L);
}
to = cursor;
break;
case '\b':
if (cursor <= from)
{
beep();
}
else if (markidx(cursor) == 0)
{
cursor -= BLKSIZE;
pfetch(markline(cursor));
cursor += plen;
}
else
{
cursor--;
}
break;
case ctrl('W'):
m = m_bword(cursor, 1L);
if (markline(m) == markline(cursor) && m >= from)
{
cursor = m;
if (from > cursor)
{
from = cursor;
}
}
else
{
beep();
}
break;
case '\n':
#if OSK
case '\l':
#else
case '\r':
#endif
#ifndef NO_ABBR
cursor = expandabbr(cursor, '\n');
#endif
build = tmpblk.c;
*build++ = '\n';
if (*o_autoindent)
{
/* figure out indent for next line */
pfetch(markline(cursor));
for (scan = ptext; *scan == ' ' || *scan == '\t'; )
{
*build++ = *scan++;
}
/* remove indent from this line, if blank */
if (!*scan && plen > 0)
{
to = cursor &= ~(BLKSIZE - 1);
delete(cursor, cursor + plen);
}
}
*build = 0;
if (cursor >= to && when != WHEN_VIREP)
{
add(cursor, tmpblk.c);
}
else
{
change(cursor, to, tmpblk.c);
}
redraw(cursor, TRUE);
to = cursor = (cursor & ~(BLKSIZE - 1))
+ BLKSIZE
+ (int)(build - tmpblk.c) - 1;
break;
case ctrl('A'):
case ctrl('P'):
if (cursor < to)
{
delete(cursor, to);
}
if (*key == ctrl('A'))
{
cutname('.');
}
to = cursor = paste(cursor, FALSE, TRUE) + 1L;
break;
case ctrl('V'):
if (cursor >= to && when != WHEN_VIREP)
{
add(cursor, "^");
}
else
{
change(cursor, to, "^");
to = cursor + 1;
}
redraw(cursor, TRUE);
*key = getkey(0);
if (*key == '\n')
{
/* '\n' too hard to handle */
#if OSK
*key = '\l';
#else
*key = '\r';
#endif
}
change(cursor, cursor + 1, key);
cursor++;
if (cursor > to)
{
to = cursor;
}
break;
case ctrl('L'):
case ctrl('R'):
redraw(MARK_UNSET, FALSE);
break;
default:
if (cursor >= to && when != WHEN_VIREP)
{
#ifndef NO_ABBR
cursor = expandabbr(cursor, *key);
#endif
add(cursor, key);
cursor++;
to = cursor;
}
else
{
pfetch(markline(cursor));
if (markidx(cursor) == plen)
{
#ifndef NO_ABBR
cursor = expandabbr(cursor, *key);
#endif
add(cursor, key);
}
else
{
#ifndef NO_DIGRAPH
*key = digraph(ptext[markidx(cursor)], *key);
#endif
#ifndef NO_ABBR
cursor = expandabbr(cursor, *key);
#endif
change(cursor, cursor + 1, key);
}
cursor++;
}
#ifndef NO_SHOWMATCH
/* show matching "({[" if neceesary */
if (*o_showmatch && strchr(")}]", *key))
{
redraw(cursor, TRUE);
m = m_match(cursor - 1, 0L);
if (markline(m) >= topline
&& markline(m) <= botline)
{
redraw(m, TRUE);
refresh();
sleep(1);
}
}
#endif
} /* end switch(*key) */
} /* end for(;;) */
BreakBreak:;
/* delete any excess characters */
if (cursor < to)
{
delete(cursor, to);
}
} /* end if doingdot else */
} /* end ChangeText */
/* put the new text into a cut buffer for possible reuse */
if (!doingdot)
{
blksync();
cutname('.');
cut(from, cursor);
}
/* move to last char that we inputted, unless it was newline */
if (markidx(cursor) != 0)
{
cursor--;
}
redraw(cursor, FALSE);
#ifndef NO_EXTENSIONS
if (quit)
{
/* if this is a nested "do", then cut it short */
abortdo();
/* exit, unless we can't write out the file */
cursor = v_xit(cursor, 0L, 'Z');
}
#endif
rptlines = 0L;
return cursor;
}